 /*******************************************************************************
  * Copyright (c) 2000, 2007 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/

 package org.eclipse.ui.internal.dialogs;

 import java.util.Arrays ;
 import java.util.Comparator ;
 import java.util.Locale ;

 import org.eclipse.core.runtime.IConfigurationElement;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.jface.dialogs.IDialogConstants;
 import org.eclipse.jface.dialogs.MessageDialog;
 import org.eclipse.jface.preference.IPreferenceStore;
 import org.eclipse.jface.preference.PreferencePage;
 import org.eclipse.jface.util.IPropertyChangeListener;
 import org.eclipse.jface.util.PropertyChangeEvent;
 import org.eclipse.jface.window.Window;
 import org.eclipse.osgi.util.NLS;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.accessibility.AccessibleAdapter;
 import org.eclipse.swt.accessibility.AccessibleEvent;
 import org.eclipse.swt.events.SelectionAdapter;
 import org.eclipse.swt.events.SelectionEvent;
 import org.eclipse.swt.events.SelectionListener;
 import org.eclipse.swt.layout.FormAttachment;
 import org.eclipse.swt.layout.FormData;
 import org.eclipse.swt.layout.FormLayout;
 import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.layout.GridLayout;
 import org.eclipse.swt.widgets.Button;
 import org.eclipse.swt.widgets.Combo;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Group;
 import org.eclipse.swt.widgets.Label;
 import org.eclipse.swt.widgets.Text;
 import org.eclipse.ui.IWorkbench;
 import org.eclipse.ui.IWorkbenchPreferenceConstants;
 import org.eclipse.ui.IWorkbenchPreferencePage;
 import org.eclipse.ui.PlatformUI;
 import org.eclipse.ui.internal.IPreferenceConstants;
 import org.eclipse.ui.internal.IWorkbenchConstants;
 import org.eclipse.ui.internal.IWorkbenchHelpContextIds;
 import org.eclipse.ui.internal.Workbench;
 import org.eclipse.ui.internal.WorkbenchMessages;
 import org.eclipse.ui.internal.WorkbenchPlugin;
 import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;
 import org.eclipse.ui.internal.themes.IThemeDescriptor;
 import org.eclipse.ui.internal.util.PrefUtil;
 import org.eclipse.ui.preferences.IWorkbenchPreferenceContainer;
 import org.eclipse.ui.progress.UIJob;
 import org.eclipse.ui.themes.ITheme;
 import org.eclipse.ui.themes.IThemeManager;

 import com.ibm.icu.text.Collator;

 /**
  * The ViewsPreferencePage is the page used to set preferences for the
  * appearance of the workbench. Originally this applied only to views but now
  * applies to the overall appearance, hence the name.
  */
 public class ViewsPreferencePage extends PreferencePage implements
         IWorkbenchPreferencePage {

     private Button showTextOnPerspectiveBar;

     /*
      * change the tab style of the workbench
      */
     private Button showTraditionalStyleTabs;

     private Button enableAnimations;

     private Button editorTopButton;

     private Button editorBottomButton;

     private Button viewTopButton;

     private Button viewBottomButton;

     private Button perspLeftButton;

     private Button perspTopLeftButton;

     private Button perspTopRightButton;

     static final String EDITORS_TITLE = WorkbenchMessages.ViewsPreference_editors;

     private static final String EDITORS_TOP_TITLE = WorkbenchMessages.ViewsPreference_editors_top;

     private static final String EDITORS_BOTTOM_TITLE = WorkbenchMessages.ViewsPreference_editors_bottom;

     private static final String VIEWS_TITLE = WorkbenchMessages.ViewsPreference_views;

     private static final String VIEWS_TOP_TITLE = WorkbenchMessages.ViewsPreference_views_top;

     private static final String VIEWS_BOTTOM_TITLE = WorkbenchMessages.ViewsPreference_views_bottom;

     private static final String PERSP_TITLE = WorkbenchMessages.ViewsPreference_perspectiveBar;

     private static final String PERSP_LEFT_TITLE = WorkbenchMessages.ViewsPreference_perspectiveBar_left;

     private static final String PERSP_TOP_LEFT_TITLE = WorkbenchMessages.ViewsPreference_perspectiveBar_topLeft;

     private static final String PERSP_TOP_RIGHT_TITLE = WorkbenchMessages.ViewsPreference_perspectiveBar_topRight;

     // These constants aren't my favourite idea, but to get this preference done
 // for M9... A better solution might be to have the presentation factory set
 // its dependant preference defaults on startup. I've filed bug 63346 to do
 // something about this area.
 private static final String R21PRESENTATION_ID = "org.eclipse.ui.internal.r21presentationFactory"; //$NON-NLS-1$
 private static final String DEFAULT_PRESENTATION_ID = IWorkbenchConstants.DEFAULT_PRESENTATION_ID;
     private static final String R30_PRESENTATION_ID = "org.eclipse.ui.presentations.r30"; //$NON-NLS-1$

     private static final String INITIAL_VAL = new String ();

     private static final int INITIAL_LOC_INT = -1;

     // remembers whether the hidden fastview bar pref needs to be changed on
 // OK/Apply
 private String fastViewLoc = INITIAL_VAL;

     private String showTextOnPerspBar = INITIAL_VAL;

     private int editorAlignment;

     private boolean editorAlignmentChanged = false;

     private int viewAlignment;

     private boolean viewAlignmentChanged = false;

     private String perspBarLocation;

     private Combo themeCombo;

     private Combo presentationCombo;

     private IConfigurationElement[] presentationFactories;

     private String currentPresentationFactoryId;

     private Button overridePresButton;

     private IPropertyChangeListener overrideListener;

     private boolean restartPosted = false;
     
     private Group editorTabGroup;
     
     private Group viewTabGroup;
     
     private Group perspBarTabGroup;
     
     private Text themeDescriptionText;

     /**
      * Create a composite that for creating the tab toggle buttons.
      *
      * @param composite Composite
      * @param title String
      */
     private Group createButtonGroup(Composite composite, String title) {
         Group buttonComposite = new Group(composite, SWT.NONE);
         buttonComposite.setText(title);
         FormLayout layout = new FormLayout();
         layout.marginWidth = 5; // same as GridData default
 layout.marginHeight = 5; // same as GridData default
 buttonComposite.setLayout(layout);
         buttonComposite.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
         return buttonComposite;
     }

     /**
      * Creates and returns the SWT control for the customized body of this
      * preference page under the given parent composite.
      * <p>
      * This framework method must be implemented by concrete subclasses.
      * </p>
      *
      * @param parent the parent composite
      * @return Control the new control
      */
     protected Control createContents(Composite parent) {
         initializeDialogUnits(parent);
         
         PlatformUI.getWorkbench().getHelpSystem().setHelp(parent,
                 IWorkbenchHelpContextIds.VIEWS_PREFERENCE_PAGE);

         IPreferenceStore internalStore = PrefUtil.getInternalPreferenceStore();
         IPreferenceStore apiStore = PrefUtil.getAPIPreferenceStore();

         editorAlignment = internalStore
                 .getInt(IPreferenceConstants.EDITOR_TAB_POSITION);
         viewAlignment = internalStore
                 .getInt(IPreferenceConstants.VIEW_TAB_POSITION);
         perspBarLocation = apiStore
                 .getString(IWorkbenchPreferenceConstants.DOCK_PERSPECTIVE_BAR);

         Composite composite = new Composite(parent, SWT.NONE);
         composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

         GridLayout layout = new GridLayout();
         layout.marginWidth = 0;
         layout.marginHeight = 0;
         layout.verticalSpacing = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
         composite.setLayout(layout);

         createPresentationCombo(composite);
         createPresentationOverride(composite);
         createEditorTabButtonGroup(composite);
         createViewTabButtonGroup(composite);
         createPerspBarTabButtonGroup(composite);
         createShowTextOnPerspectiveBarPref(composite);
         createThemeCombo(composite);
         createThemeDescriptionText(composite);
         createShowTraditionalStyleTabsPref(composite);
         createEnableAnimationsPref(composite);

         updateOverride();
         hookOverrideListener();
         
         applyDialogFont(composite);
         
         return composite;
     }

     private void createThemeCombo(Composite composite) {
         new Label(composite, SWT.NONE).setText(WorkbenchMessages.ViewsPreference_currentTheme);
         themeCombo = new Combo(composite, SWT.READ_ONLY);
         themeCombo.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
         themeCombo.addSelectionListener(new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 refreshThemeDescriptionText();
             }
         });
         refreshThemeCombo(PlatformUI.getWorkbench().getThemeManager().getCurrentTheme().getId());
     }

      
     /**
      * Create the text box that will contain the current theme description
      * text (if any).
      *
      * @param parent
      * the parent <code>Composite</code>.
      */
     private void createThemeDescriptionText(Composite parent) {
         new Label(parent, SWT.NONE)
                 .setText(WorkbenchMessages.ViewsPreference_currentThemeDescription);

         themeDescriptionText = new Text(parent, SWT.H_SCROLL | SWT.V_SCROLL
                 | SWT.READ_ONLY | SWT.BORDER | SWT.WRAP);
         themeDescriptionText.setLayoutData(new GridData(SWT.FILL, SWT.FILL,
                 true, true));

         refreshThemeDescriptionText();
     }
     
     private void refreshThemeDescriptionText() {
         String description = null;
         int idx = themeCombo.getSelectionIndex();
         // idx == 0 is "Default" which has no description
 if (idx > 0) {
             IThemeDescriptor theme = WorkbenchPlugin.getDefault()
                     .getThemeRegistry().getThemes()[idx - 1];
             description = theme.getDescription();
         }
         if (description == null) {
             description = ""; //$NON-NLS-1$
 }
         themeDescriptionText.setText(description);
     }

     private Button createCheckButton(Composite composite, String text, boolean selection) {
         Button button = new Button(composite, SWT.CHECK);
         button.setText(text);
         button.setSelection(selection);
         return button;
     }
     
     private void createPresentationOverride(Composite parent) {
         IPreferenceStore store = getPreferenceStore();
         boolean override = store.getBoolean(IPreferenceConstants.OVERRIDE_PRESENTATION);
         
         // workaround to catch the case where the show text value was changed outside of this page
 // turn off text on persp bar
 boolean showText = PrefUtil.getAPIPreferenceStore().getBoolean(IWorkbenchPreferenceConstants.SHOW_TEXT_ON_PERSPECTIVE_BAR);
         if (showText && isR21(currentPresentationFactoryId) || !showText && isR30(currentPresentationFactoryId)) {
             if (!override) {
                 store.setValue(IPreferenceConstants.OVERRIDE_PRESENTATION, true);
                 override = true;
             }
         }
         // workaround to catch the case where the perspective switcher location was changed outside of this page
 // turn off text on persp bar
 String barLocation = PrefUtil.getAPIPreferenceStore().getString(IWorkbenchPreferenceConstants.DOCK_PERSPECTIVE_BAR);
         if (!barLocation.equals(IWorkbenchPreferenceConstants.LEFT) && isR21(currentPresentationFactoryId) || !barLocation.equals(IWorkbenchPreferenceConstants.TOP_RIGHT) && isR30(currentPresentationFactoryId)) {
             if (!override) {
                 store.setValue(IPreferenceConstants.OVERRIDE_PRESENTATION, true);
                 override = true;
             }
         }
             
         overridePresButton = createCheckButton(parent, WorkbenchMessages.ViewsPreference_override, override);
         overridePresButton.addSelectionListener(new SelectionListener() {
             public void widgetSelected(SelectionEvent e) {
                 updateOverrideState(overridePresButton.getSelection());
             }

             public void widgetDefaultSelected(SelectionEvent e) {
                 updateOverrideState(overridePresButton.getSelection());
             }
         });
     }

     private void updateOverrideState(boolean override) {
         IPreferenceStore store = getPreferenceStore();
         if (store.getBoolean(IPreferenceConstants.OVERRIDE_PRESENTATION) != override) {
             store
                     .setValue(IPreferenceConstants.OVERRIDE_PRESENTATION,
                             override);
         }
         // as we are no longer overriding the prefs should match the selected
 // presentation
 if (!override)
             setPresentationPrefs(getSelectedPresentationID());
     }

     private void createPresentationCombo(Composite parent) {
         new Label(parent, SWT.NONE).setText(WorkbenchMessages.ViewsPreference_currentPresentation);

         presentationCombo = new Combo(parent, SWT.READ_ONLY);
         presentationCombo.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
         presentationCombo.addSelectionListener(new SelectionListener() {

             public void widgetSelected(SelectionEvent e) {
                 updateSettings();
             }

             public void widgetDefaultSelected(SelectionEvent e) {
                 updateSettings();
             }

             private void updateSettings() {
                 if (!overridePresButton.getSelection()) {
                     setPresentationPrefs(getSelectedPresentationID());
                 }
             }
         });

         refreshPresentationCombo();
         setPresentationSelection();
     }

     /**
      * Set the two supplied controls to be beside each other.
      */
     private void attachControls(Control leftControl, Control rightControl) {
         FormData leftData = new FormData();
         leftData.left = new FormAttachment(0, 0);

         FormData rightData = new FormData();
         rightData.left = new FormAttachment(leftControl, convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING));

         leftControl.setLayoutData(leftData);
         rightControl.setLayoutData(rightData);
     }

     /**
      * Create a composite that contains buttons for selecting tab position for
      * the edit selection.
      *
      * @param composite Composite
      */
     private void createEditorTabButtonGroup(Composite composite) {
         editorTabGroup = createButtonGroup(composite, EDITORS_TITLE);

         editorTopButton = new Button(editorTabGroup, SWT.RADIO);
         editorTopButton.setText(EDITORS_TOP_TITLE);
         editorTopButton.setSelection(editorAlignment == SWT.TOP);
         editorTopButton.getAccessible().addAccessibleListener(
                 new AccessibleAdapter() {
                     public void getName(AccessibleEvent e) {
                         e.result = EDITORS_TITLE;
                     }
                 });

         editorBottomButton = new Button(editorTabGroup, SWT.RADIO);
         editorBottomButton.setText(EDITORS_BOTTOM_TITLE);
         editorBottomButton.setSelection(editorAlignment == SWT.BOTTOM);

         SelectionListener sel = new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 if (e.widget.equals(editorTopButton)) {
                     if (editorAlignment != SWT.TOP) {
                         editorAlignment = SWT.TOP;
                         editorAlignmentChanged = true;
                     }
                 } else if (e.widget.equals(editorBottomButton)) {
                     if (editorAlignment != SWT.BOTTOM) {
                         editorAlignment = SWT.BOTTOM;
                         editorAlignmentChanged = true;
                     }
                 }
             }
         };

         editorTopButton.addSelectionListener(sel);
         editorBottomButton.addSelectionListener(sel);

         attachControls(editorTopButton, editorBottomButton);
     }

     /**
      * Create a composite that contains buttons for selecting tab position for
      * the view selection.
      *
      * @param composite Composite
      */
     private void createViewTabButtonGroup(Composite composite) {
         viewTabGroup = createButtonGroup(composite, VIEWS_TITLE);

         viewTopButton = new Button(viewTabGroup, SWT.RADIO);
         viewTopButton.setText(VIEWS_TOP_TITLE);
         viewTopButton.setSelection(this.viewAlignment == SWT.TOP);

         viewBottomButton = new Button(viewTabGroup, SWT.RADIO);
         viewBottomButton.setText(VIEWS_BOTTOM_TITLE);
         viewBottomButton.setSelection(viewAlignment == SWT.BOTTOM);

         SelectionListener sel = new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 if (e.widget.equals(viewTopButton)) {
                     if (viewAlignment != SWT.TOP) {
                         viewAlignment = SWT.TOP;
                         viewAlignmentChanged = true;
                     }
                 } else if (e.widget.equals(viewBottomButton)) {
                     if (viewAlignment != SWT.BOTTOM) {
                         viewAlignment = SWT.BOTTOM;
                         viewAlignmentChanged = true;
                     }
                 }
             }
         };

         viewTopButton.addSelectionListener(sel);
         viewBottomButton.addSelectionListener(sel);

         attachControls(viewTopButton, viewBottomButton);
     }

     /**
      * Create a composite that contains buttons for selecting perspective
      * switcher position.
      *
      * @param composite Composite
      */
     private void createPerspBarTabButtonGroup(Composite composite) {
         perspBarTabGroup = createButtonGroup(composite, PERSP_TITLE);

         perspLeftButton = new Button(perspBarTabGroup, SWT.RADIO);
         perspLeftButton.setText(PERSP_LEFT_TITLE);
         perspLeftButton.setSelection(IWorkbenchPreferenceConstants.LEFT
                 .equals(perspBarLocation));
         perspLeftButton.addSelectionListener(new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 perspBarLocation = IWorkbenchPreferenceConstants.LEFT;
             }
         });

         perspTopLeftButton = new Button(perspBarTabGroup, SWT.RADIO);
         perspTopLeftButton.setText(PERSP_TOP_LEFT_TITLE);
         perspTopLeftButton.setSelection(IWorkbenchPreferenceConstants.TOP_LEFT
                 .equals(perspBarLocation));
         perspTopLeftButton.addSelectionListener(new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 perspBarLocation = IWorkbenchPreferenceConstants.TOP_LEFT;
             }
         });

         perspTopRightButton = new Button(perspBarTabGroup, SWT.RADIO);
         perspTopRightButton.setText(PERSP_TOP_RIGHT_TITLE);
         perspTopRightButton
                 .setSelection(IWorkbenchPreferenceConstants.TOP_RIGHT
                         .equals(perspBarLocation));
         perspTopRightButton.addSelectionListener(new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 perspBarLocation = IWorkbenchPreferenceConstants.TOP_RIGHT;
             }
         });

         int spacing = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
         
         FormData leftData = new FormData();
         leftData.left = new FormAttachment(0, 0);

         FormData topLeftData = new FormData();
         topLeftData.left = new FormAttachment(perspLeftButton, spacing);

         FormData topRightData = new FormData();
         topRightData.left = new FormAttachment(perspTopLeftButton, spacing);

         perspLeftButton.setLayoutData(leftData);
         perspTopLeftButton.setLayoutData(topLeftData);
         perspTopRightButton.setLayoutData(topRightData);
     }

     /**
      * Hook a listener to update the buttons based on an override preference. If
      * the preference is false then do not allow editing of these options.
      *
      */
     private void hookOverrideListener() {
         if (overrideListener != null) {
             return;
         }
         IPreferenceStore store = getPreferenceStore();
         overrideListener = new IPropertyChangeListener() {
             public void propertyChange(PropertyChangeEvent event) {
                 if (event.getProperty().equals(
                         IPreferenceConstants.OVERRIDE_PRESENTATION)) {
                     updateOverride();
                 }
             }
         };
         store.addPropertyChangeListener(overrideListener);
     }

     /**
      * Dispose resources created by the receiver.
      */
     public void dispose() {
         super.dispose();
         if (overrideListener != null) {
             getPreferenceStore().removePropertyChangeListener(overrideListener);
             overrideListener = null;
         }
     }

     private void updateOverride() {
         boolean override = getPreferenceStore().getBoolean(
                 IPreferenceConstants.OVERRIDE_PRESENTATION);
         editorTabGroup.setEnabled(override);
         editorTopButton.setEnabled(override);
         editorBottomButton.setEnabled(override);
         viewTabGroup.setEnabled(override);
         viewTopButton.setEnabled(override);
         viewBottomButton.setEnabled(override);
         perspBarTabGroup.setEnabled(override);
         perspTopLeftButton.setEnabled(override);
         perspLeftButton.setEnabled(override);
         perspTopRightButton.setEnabled(override);
         showTextOnPerspectiveBar.setEnabled(override);
     }

     private void refreshPresentationCombo() {
         // get the active presentation
 presentationCombo.removeAll();
         refreshPresentationFactories();

         for (int i = 0; i < presentationFactories.length; ++i) {
             IConfigurationElement el = presentationFactories[i];
             String name = el.getAttribute(IWorkbenchConstants.TAG_NAME);
             if (!currentPresentationFactoryId.equals(el
                     .getAttribute(IWorkbenchConstants.TAG_ID))) {
                 presentationCombo.add(name);
             } else {
                 presentationCombo
                     .add(NLS.bind(
                         WorkbenchMessages.ViewsPreference_currentPresentationFormat,
                         name));
             }
         }
     }

     private void setPresentationSelection() {
         for (int i = 0; i < presentationFactories.length; ++i) {
             if (currentPresentationFactoryId.equals(presentationFactories[i]
                     .getAttribute(IWorkbenchConstants.TAG_ID))) {
                 presentationCombo.select(i);
                 return;
             }
         }
         //presentationCombo.select(0);
 }

     /**
      * Update this page's list of presentation factories. This should only be
      * used when the presentation combo is refreshed, as this array will be used
      * to set the selection from the combo.
      */
     private void refreshPresentationFactories() {
         // update the current selection (used to look for changes on apply)
 currentPresentationFactoryId = PrefUtil.getAPIPreferenceStore()
                 .getString(
                         IWorkbenchPreferenceConstants.PRESENTATION_FACTORY_ID);
         // Workbench.getInstance().getPresentationId();

         // update the sorted list of factories
 presentationFactories = Platform.getExtensionRegistry()
                 .getConfigurationElementsFor(PlatformUI.PLUGIN_ID,
                         IWorkbenchRegistryConstants.PL_PRESENTATION_FACTORIES);

         // sort the array by name
 Arrays.sort(presentationFactories, new Comparator () {
             Collator collator = Collator.getInstance(Locale.getDefault());

             public int compare(Object a, Object b) {
                 IConfigurationElement el1 = (IConfigurationElement) a;
                 IConfigurationElement el2 = (IConfigurationElement) b;
                 return collator.compare(el1
                         .getAttribute(IWorkbenchConstants.TAG_NAME), el2
                         .getAttribute(IWorkbenchConstants.TAG_NAME));
             }
         });
     }

     /**
      * Update the preferences associated with the argument presentation factory.
      *
      * @return boolean
      * <code>true<\code> of the presentation has changed and <code>false<\code> otherwise
      */
     private boolean updatePresentationPreferences() {
         // There are some preference values associated with the R2.1
 // presentation that cannot be captured in the presentation
 // factory. Perhaps the extension point should contain these
 // (a list of attributes?), but for now it is done manually.

         if (presentationCombo == null) {
             return false;
         }

         String id = getSelectedPresentationID();

         // if it hasn't changed then there's nothing to do
 if (id.equals(currentPresentationFactoryId)) {
             return false;
         }

         currentPresentationFactoryId = id;
         // apply 2.1 prefs if needed
 setPresentationPrefs(id);
         // set the new presentation factory id
 PrefUtil.getAPIPreferenceStore().putValue(
                 IWorkbenchPreferenceConstants.PRESENTATION_FACTORY_ID, id);
         // a restart is required to update the presentation
 return true;
     }

     private void setPresentationPrefs(String id) {
         if (isR21(id)) {
             setR21Preferences();
         } else if (isR30(id)) {
             setR30Preferences();
         } else if (isR33(id)) {
             setR33Preferences();
         }
     }

     private boolean isR33(String id) {
         return DEFAULT_PRESENTATION_ID.equals(id);
     }

     private boolean isR30(String id) {
         return R30_PRESENTATION_ID.equals(id);
     }

     private boolean isR21(String id) {
         return R21PRESENTATION_ID.equals(id);
     }

     private String getSelectedPresentationID() {
         int selection = presentationCombo.getSelectionIndex();
         IConfigurationElement element = presentationFactories[selection];
         String id = element.getAttribute(IWorkbenchConstants.TAG_ID);
         return id;
     }

     private void setR33Preferences() {
         setR30Preferences();
         
         // Turn -on- the new Min/Max behaviour
 IPreferenceStore apiStore = PrefUtil.getAPIPreferenceStore();
         apiStore.setValue(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX, true);
     }

     private void setR30Preferences() {
         IPreferenceStore internalStore = PrefUtil.getInternalPreferenceStore();
         IPreferenceStore apiStore = PrefUtil.getAPIPreferenceStore();

         // Turn -off- the new min/max behaviour
 apiStore.setValue(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX, false);

         setEditorAlignDefault(internalStore);
         setViewAlignDefault(internalStore);

         // perspective switcher on the left
 perspBarLocation = apiStore
                 .getDefaultString(IWorkbenchPreferenceConstants.DOCK_PERSPECTIVE_BAR);
         perspLeftButton.setSelection(perspBarLocation
                 .equals(IWorkbenchPreferenceConstants.LEFT));
         perspTopLeftButton.setSelection(perspBarLocation
                 .equals(IWorkbenchPreferenceConstants.TOP_LEFT));
         perspTopRightButton.setSelection(perspBarLocation
                 .equals(IWorkbenchPreferenceConstants.TOP_RIGHT));

         // perspective bar should be set to default on OK or Apply
 perspBarLocation = INITIAL_VAL;

         // turn off text on persp bar
 showTextOnPerspectiveBar
                 .setSelection(apiStore
                         .getDefaultBoolean(IWorkbenchPreferenceConstants.SHOW_TEXT_ON_PERSPECTIVE_BAR));
         // text on perspective bar should be set to default on OK or Apply
 showTextOnPerspBar = INITIAL_VAL;

         // fast view bar should be set to default on OK or Apply
 fastViewLoc = INITIAL_VAL;
     }

     private void setViewAlignDefault(IPreferenceStore internalStore) {
         int oldVal;
         // reset the preferences for 3.0 presentation
 oldVal = viewAlignment;
         viewAlignment = internalStore
                 .getDefaultInt(IPreferenceConstants.VIEW_TAB_POSITION);
         viewTopButton.setSelection(viewAlignment == SWT.TOP);
         viewBottomButton.setSelection(viewAlignment == SWT.BOTTOM);

         // view tabs should be set to default on OK or Apply
 if (oldVal != viewAlignment) {
             viewAlignmentChanged = true;
         }
         viewAlignment = INITIAL_LOC_INT;
     }

     private void setEditorAlignDefault(IPreferenceStore internalStore) {
         // editor tabs on the bottom, really should associate this with the
 // presentation
 int oldVal = editorAlignment;
         editorAlignment = internalStore
                 .getDefaultInt(IPreferenceConstants.EDITOR_TAB_POSITION);
         editorTopButton.setSelection(editorAlignment == SWT.TOP);
         editorBottomButton.setSelection(editorAlignment == SWT.BOTTOM);

         // editor tabs should be set to default on OK or Apply
 if (oldVal != editorAlignment) {
             editorAlignmentChanged = true;
         }
         editorAlignment = INITIAL_LOC_INT;
     }

     private void setR21Preferences() {
         // editor tabs on the bottom, really should associate this with the
 // presentation
 int oldVal = editorAlignment;
         editorAlignment = SWT.TOP;
         editorTopButton.setSelection(editorAlignment == SWT.TOP);
         editorBottomButton.setSelection(editorAlignment == SWT.BOTTOM);
         if (oldVal != editorAlignment) {
             editorAlignmentChanged = true;
         }

         // view tabs on the bottom, really should associate this with the
 // presentation
 oldVal = viewAlignment;
         viewAlignment = SWT.BOTTOM;
         viewTopButton.setSelection(viewAlignment == SWT.TOP);
         viewBottomButton.setSelection(viewAlignment == SWT.BOTTOM);
         if (oldVal != viewAlignment) {
             viewAlignmentChanged = true;
         }

         // perspective switcher on the left, really should associate this with
 // the presentation
 perspBarLocation = IWorkbenchPreferenceConstants.LEFT;
         perspLeftButton.setSelection(perspBarLocation
                 .equals(IWorkbenchPreferenceConstants.LEFT));
         perspTopLeftButton.setSelection(perspBarLocation
                 .equals(IWorkbenchPreferenceConstants.TOP_LEFT));
         perspTopRightButton.setSelection(perspBarLocation
                 .equals(IWorkbenchPreferenceConstants.TOP_RIGHT));

         // turn off text on persp bar, really should associate this with the
 // presentation
 showTextOnPerspectiveBar.setSelection(false);
         showTextOnPerspBar = String.valueOf(false);

         // fast view bar on the left (hidden pref, set it directly)
 fastViewLoc = IWorkbenchPreferenceConstants.LEFT;

         // Turn -off- the new min/max behaviour
 IPreferenceStore apiStore = PrefUtil.getAPIPreferenceStore();
         apiStore.setValue(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX, false);
     }

     /**
      * @param themeToSelect the id of the theme to be selected
      */
     private void refreshThemeCombo(String themeToSelect) {
         themeCombo.removeAll();
         ITheme currentTheme = PlatformUI.getWorkbench().getThemeManager()
                 .getCurrentTheme();

         IThemeDescriptor[] descs = WorkbenchPlugin.getDefault()
                 .getThemeRegistry().getThemes();
         String defaultThemeString = PlatformUI.getWorkbench().getThemeManager()
                 .getTheme(IThemeManager.DEFAULT_THEME).getLabel();
         if (currentTheme.getId().equals(IThemeManager.DEFAULT_THEME)) {
             defaultThemeString = NLS.bind(
                     WorkbenchMessages.ViewsPreference_currentThemeFormat,
                     new Object [] { defaultThemeString });
         }
         themeCombo.add(defaultThemeString);
         
         String themeString;
         int selection = 0;
         for (int i = 0; i < descs.length; i++) {
             themeString = descs[i].getName();
             if (descs[i].getId().equals(currentTheme.getId())) {
                 themeString = NLS.bind(
                         WorkbenchMessages.ViewsPreference_currentThemeFormat,
                         new Object [] { themeString });
             }
             if (themeToSelect.equals(descs[i].getId())) {
                 selection = i + 1;
             }
             themeCombo.add(themeString);
         }
         themeCombo.select(selection);
     }

     /**
      * Create the button and text that support setting the preference for
      * showing text labels on the perspective switching bar.
      */
     protected void createShowTextOnPerspectiveBarPref(Composite composite) {
         IPreferenceStore apiStore = PrefUtil.getAPIPreferenceStore();

         showTextOnPerspectiveBar = createCheckButton(
                 composite,
                 WorkbenchMessages.WorkbenchPreference_showTextOnPerspectiveBar,
                 apiStore
                         .getBoolean(IWorkbenchPreferenceConstants.SHOW_TEXT_ON_PERSPECTIVE_BAR));
     }

     /**
      * Create the button and text that support setting the preference for
      * showing text labels on the perspective switching bar
      */
     protected void createShowTraditionalStyleTabsPref(Composite composite) {
         IPreferenceStore apiStore = PrefUtil.getAPIPreferenceStore();

         showTraditionalStyleTabs = createCheckButton(
                 composite,
                 WorkbenchMessages.ViewsPreference_traditionalTabs,
                 apiStore
                         .getBoolean(IWorkbenchPreferenceConstants.SHOW_TRADITIONAL_STYLE_TABS));
     }

     protected void createEnableAnimationsPref(Composite composite) {
         IPreferenceStore apiStore = PrefUtil.getAPIPreferenceStore();

         enableAnimations = createCheckButton(
                 composite,
                 WorkbenchMessages.ViewsPreference_enableAnimations,
                 apiStore
                         .getBoolean(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS));
     }

     /**
      * Returns preference store that belongs to the our plugin.
      *
      * @return IPreferenceStore the preference store for this plugin
      */
     protected IPreferenceStore doGetPreferenceStore() {
         return WorkbenchPlugin.getDefault().getPreferenceStore();
     }

     /**
      * Initializes this preference page for the given workbench.
      * <p>
      * This method is called automatically as the preference page is being
      * created and initialized. Clients must not call this method.
      * </p>
      *
      * @param workbench the workbench
      */
     public void init(IWorkbench workbench) {
         currentPresentationFactoryId = PrefUtil.getAPIPreferenceStore()
                 .getString(
                         IWorkbenchPreferenceConstants.PRESENTATION_FACTORY_ID);
     }

     /**
      * The default button has been pressed.
      */
     protected void performDefaults() {
         IPreferenceStore store = getPreferenceStore();
         IPreferenceStore apiStore = PrefUtil.getAPIPreferenceStore();

         showTextOnPerspectiveBar
                 .setSelection(apiStore
                         .getDefaultBoolean(IWorkbenchPreferenceConstants.SHOW_TEXT_ON_PERSPECTIVE_BAR));
         showTraditionalStyleTabs
                 .setSelection(apiStore
                         .getDefaultBoolean(IWorkbenchPreferenceConstants.SHOW_TRADITIONAL_STYLE_TABS));
         enableAnimations
                 .setSelection(apiStore
                         .getDefaultBoolean(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS));

         String presID = apiStore
                 .getDefaultString(IWorkbenchPreferenceConstants.PRESENTATION_FACTORY_ID);
         currentPresentationFactoryId = presID;
         setPresentationSelection();

         boolean overridePrefs = store
                 .getDefaultBoolean(IPreferenceConstants.OVERRIDE_PRESENTATION);
         overridePresButton.setSelection(overridePrefs);

         updateOverrideState(overridePrefs);
         
         setEditorAlignDefault(store);
         setViewAlignDefault(store);

         perspBarLocation = apiStore
                 .getDefaultString(IWorkbenchPreferenceConstants.DOCK_PERSPECTIVE_BAR);
         perspLeftButton.setSelection(IWorkbenchPreferenceConstants.LEFT
                 .equals(perspBarLocation));
         perspTopLeftButton.setSelection(IWorkbenchPreferenceConstants.TOP_LEFT
                 .equals(perspBarLocation));
         perspTopRightButton
                 .setSelection(IWorkbenchPreferenceConstants.TOP_RIGHT
                         .equals(perspBarLocation));

         refreshThemeCombo(PlatformUI.getWorkbench().getThemeManager()
                 .getTheme(IThemeManager.DEFAULT_THEME).getId());
         refreshThemeDescriptionText();
         
         WorkbenchPlugin.getDefault().savePluginPreferences();
         
         super.performDefaults();
     }

     /**
      * The user has pressed Ok. Store/apply this page's values appropriately.
      */
     public boolean performOk() {
         IPreferenceStore store = getPreferenceStore();
         IPreferenceStore apiStore = PrefUtil.getAPIPreferenceStore();
         boolean override = store
                 .getBoolean(IPreferenceConstants.OVERRIDE_PRESENTATION);

         // apply the presentation selection first since it might change some of
 // the other values
 boolean restart = updatePresentationPreferences();

         if (showTextOnPerspBar.equals(INITIAL_VAL) && !override) {
             apiStore
                     .setToDefault(IWorkbenchPreferenceConstants.SHOW_TEXT_ON_PERSPECTIVE_BAR);
         } else {
             apiStore.setValue(
                     IWorkbenchPreferenceConstants.SHOW_TEXT_ON_PERSPECTIVE_BAR,
                     showTextOnPerspectiveBar.getSelection());
         }

         if (editorAlignmentChanged) {
             if (editorAlignment == INITIAL_LOC_INT) {
                 store.setToDefault(IPreferenceConstants.EDITOR_TAB_POSITION);
             } else if (!override) {
                 // store the editor tab value to setting
 store.setValue(IPreferenceConstants.EDITOR_TAB_POSITION,
                         editorAlignment);
             } else {
                 // store the editor tab value to setting
 store.setValue(IPreferenceConstants.EDITOR_TAB_POSITION,
                         editorAlignment);
             }
             restart = true;
         }

         if (viewAlignmentChanged) {
             if (viewAlignment == INITIAL_LOC_INT) {
                store.setToDefault(IPreferenceConstants.VIEW_TAB_POSITION);
            } else if (!override) {
                // store the view tab value to setting
 store.setValue(IPreferenceConstants.VIEW_TAB_POSITION,
                        viewAlignment);
            } else {
                // store the view tab value to setting
 store.setValue(IPreferenceConstants.VIEW_TAB_POSITION,
                        viewAlignment);
            }
            restart = true;
        }

        if (perspBarLocation.equals(INITIAL_VAL)) {
            apiStore
                    .setToDefault(IWorkbenchPreferenceConstants.DOCK_PERSPECTIVE_BAR);
        } else if (!override) {
            // store the perspective bar text enabled setting
 apiStore.setValue(
                    IWorkbenchPreferenceConstants.DOCK_PERSPECTIVE_BAR,
                    perspBarLocation);
        } else {
            // store the perspective bar text enabled setting
 apiStore.setValue(
                    IWorkbenchPreferenceConstants.DOCK_PERSPECTIVE_BAR,
                    perspBarLocation);
        }

        if (fastViewLoc.equals(INITIAL_VAL)) {
            apiStore
                    .setToDefault(IWorkbenchPreferenceConstants.INITIAL_FAST_VIEW_BAR_LOCATION);
        } else {
            apiStore
                    .setValue(
                            IWorkbenchPreferenceConstants.INITIAL_FAST_VIEW_BAR_LOCATION,
                            fastViewLoc);
        }

        int idx = themeCombo.getSelectionIndex();
        if (idx <= 0) {
            Workbench.getInstance().getThemeManager().setCurrentTheme(
                    IThemeManager.DEFAULT_THEME);
            refreshThemeCombo(IThemeManager.DEFAULT_THEME);
        } else {
            IThemeDescriptor applyTheme = WorkbenchPlugin.getDefault().getThemeRegistry().getThemes()[idx - 1];
            Workbench.getInstance().getThemeManager()
                    .setCurrentTheme(applyTheme.getId());
            refreshThemeCombo(applyTheme.getId());
        }
        refreshThemeDescriptionText();
        
        apiStore.setValue(
                IWorkbenchPreferenceConstants.SHOW_TRADITIONAL_STYLE_TABS,
                showTraditionalStyleTabs.getSelection());
        apiStore.setValue(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS,
                enableAnimations.getSelection());

        PrefUtil.savePrefs();

        // we can get here through performApply, in that case only post one
 // restart
 if (restart && !restartPosted) {
            if (getContainer() instanceof IWorkbenchPreferenceContainer) {
                IWorkbenchPreferenceContainer container = (IWorkbenchPreferenceContainer) getContainer();
                UIJob job = new UIJob(WorkbenchMessages.ViewsPreference_restartRequestJobName) {
                    public IStatus runInUIThread(IProgressMonitor monitor) {
                        // make sure they really want to do this
 int really = new MessageDialog(
                                null,
                                WorkbenchMessages.ViewsPreference_presentationConfirm_title,
                                null,
                                WorkbenchMessages.ViewsPreference_presentationConfirm_message,
                                MessageDialog.QUESTION,
                                new String [] {
                                        WorkbenchMessages.ViewsPreference_presentationConfirm_yes,
                                        WorkbenchMessages.ViewsPreference_presentationConfirm_no },
                                1).open();
                        if (really == Window.OK) {
                            PlatformUI.getWorkbench().restart();
                        }
                        return Status.OK_STATUS;
                    }
                };
                job.setSystem(true);
                container.registerUpdateJob(job);
                restartPosted = true;
            }
        }
        return true;
    }
}

